home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / PALETTE.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  7KB  |  236 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1992, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.4  $
  6. //
  7. // Implementation of TPalette, an encapsulation of the GDI Palette object
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_GDIOBJEC_H)
  11. # include <owl/gdiobjec.h>
  12. #endif
  13. #if !defined(OWL_CLIPBOAR_H)
  14. # include <owl/clipboar.h>
  15. #endif
  16. #include <memory.h>
  17.  
  18. OWL_DIAGINFO;
  19. DIAG_DECLARE_GROUP(OwlGDI);        // General GDI diagnostic group
  20. DIAG_DECLARE_GROUP(OwlGDIOrphan);  // Orphan control tracing group
  21.  
  22. //
  23. // Constructors
  24. //
  25.  
  26. //
  27. // Alias an existing palette handle. Assume ownership if autoDelete says so
  28. //
  29. TPalette::TPalette(HPALETTE handle, TAutoDelete autoDelete)
  30. :
  31.   TGdiObject(handle, autoDelete)
  32. {
  33.   if (ShouldDelete)
  34.     RefAdd(Handle, Palette);
  35. }
  36.  
  37. //
  38. // Construct a TPalette by pulling a palette handle from the clipboard
  39. //
  40. TPalette::TPalette(const TClipboard& clipboard)
  41. :
  42.   TGdiObject(clipboard.GetClipboardData(CF_PALETTE))
  43. {
  44.   WARNX(OwlGDI, !Handle, 0, "Cannot create TPalette from the clipboard");
  45.   CheckValid();
  46.   RefAdd(Handle, Palette);
  47.   RefInc(Handle);
  48. }
  49.  
  50. //
  51. // Construct a copy of an existing palette. Always performs full, deep object
  52. // copy
  53. //
  54. TPalette::TPalette(const TPalette& src)
  55. {
  56.   uint16  nColors;
  57.   src.GetObject(nColors);
  58.   if (nColors) {
  59.     LOGPALETTE* logPal = (LOGPALETTE*) new
  60.       uint8[sizeof(LOGPALETTE)+(nColors-1)*sizeof(PALETTEENTRY)];
  61.  
  62.     logPal->palVersion = 0x300;  
  63.     logPal->palNumEntries = nColors;
  64.     src.GetPaletteEntries(0, nColors, logPal->palPalEntry);
  65.     Handle = ::CreatePalette(logPal);
  66.     delete[] logPal;
  67.   }
  68.   else
  69.     Handle = 0;  // Force a failure
  70.  
  71.   WARNX(OwlGDI, !Handle, 0, "Cannot create palette from palette " <<
  72.         uint(HPALETTE(src)));
  73.   CheckValid();
  74.   RefAdd(Handle, Palette);
  75. }
  76.  
  77. //
  78. // Construct a TPalette given a logical palette object
  79. //
  80. TPalette::TPalette(const LOGPALETTE far* logPalette)
  81. {
  82.   PRECONDITION(logPalette);
  83.   Handle = ::CreatePalette(logPalette);
  84.   WARNX(OwlGDI, !Handle, 0, "Cannot create palette from logPalette @" <<
  85.         hex << uint32(LPVOID(logPalette)));
  86.   CheckValid();
  87.   RefAdd(Handle, Palette);
  88. }
  89.  
  90. //
  91. // Construct a TPalette given a palette entry array
  92. //
  93. TPalette::TPalette(const PALETTEENTRY far* entries, int count)
  94. {
  95.   LOGPALETTE* logPal = (LOGPALETTE*)new uint8[
  96.      sizeof(LOGPALETTE)+(count-1)*sizeof(PALETTEENTRY) ];
  97.  
  98.   logPal->palVersion  = 0x300;
  99.   logPal->palNumEntries = (uint16)count;
  100.   memcpy(logPal->palPalEntry, entries, count*sizeof(PALETTEENTRY));
  101.   Handle = ::CreatePalette(logPal);
  102.   delete[] logPal;
  103.  
  104.   WARNX(OwlGDI, !Handle, 0, "Cannot create palette from " << count <<
  105.         "palette entries @" << hex << uint32(LPVOID(entries)));
  106.   CheckValid();
  107.   RefAdd(Handle, Palette);
  108. }
  109.  
  110. //
  111. // Construct a TPalette from the bitmap info from a DIB
  112. //
  113. TPalette::TPalette(const BITMAPINFO far* info, uint flags)
  114. {
  115.   Create(info, flags);
  116. }
  117.  
  118. //
  119. // Construct a TPalette from a TDib
  120. //
  121. TPalette::TPalette(const TDib& dib, uint flags)
  122. {
  123.   Create(dib.GetInfo(), flags);
  124. }
  125.  
  126. //
  127. // Accept a pointer to a BITMAPINFO structure and create a GDI logical
  128. // palette from the color table which follows it, for 2, 16 and 256 color
  129. // bitmaps. Fail for all others, including 24-bit DIB's
  130. //
  131. void
  132. TPalette::Create(const BITMAPINFO far* info, uint flags)
  133. {
  134.   const RGBQUAD far* rgb = info->bmiColors;
  135.  
  136.   // if the ClrUsed field of the header is non-zero,
  137.   // it means that we could have have a short color table.
  138.   //
  139.   uint16 nColors = uint16(info->bmiHeader.biClrUsed ?
  140.            info->bmiHeader.biClrUsed :
  141.            NColors(info->bmiHeader.biBitCount));
  142.  
  143.   if (nColors) {
  144.     LOGPALETTE* logPal = (LOGPALETTE*)
  145.        new uint8[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
  146.  
  147.     logPal->palVersion  = 0x300;      // Windows 3.0 version
  148.     logPal->palNumEntries = nColors;
  149.     for (uint16 n = 0; n < nColors; n++) {
  150.       logPal->palPalEntry[n].peRed   = rgb[n].rgbRed;
  151.       logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
  152.       logPal->palPalEntry[n].peBlue  = rgb[n].rgbBlue;
  153.       logPal->palPalEntry[n].peFlags = (uint8)flags;
  154.     }
  155.     Handle = ::CreatePalette(logPal);
  156.     delete[] logPal;
  157.   }
  158.   else
  159.     Handle = 0;
  160.  
  161.   WARNX(OwlGDI, !Handle, 0, "Cannot create palette from bitmapinfo @" <<
  162.         hex << uint32(LPVOID(info)));
  163.   CheckValid();
  164.   RefAdd(Handle, Palette);
  165. }
  166.  
  167. //
  168. // Move this palette handle to the clipboard.  Clipboard assumes ownership,
  169. // this TPalette will not delete the handle
  170. //
  171. void
  172. TPalette::ToClipboard(TClipboard& clipboard)
  173. {
  174.   if (Handle) {
  175.     clipboard.SetClipboardData(CF_PALETTE, Handle);
  176.     ShouldDelete = false; // GDI object now owned by Clipboard
  177.     RefRemove(Handle);
  178.   }
  179. }
  180.  
  181. //
  182. // Obsolete PM core info based palette construction. TDib now always converts
  183. // PM DIBs to Windows DIBs when reading.
  184. //
  185. #if defined(OWL2_COMPAT)
  186. //
  187. //
  188. //
  189. TPalette::TPalette(const BITMAPCOREINFO far* core, uint flags)
  190. {
  191.   Create(core, flags);
  192. }
  193.  
  194. //
  195. // Accept a pointer to a BITMAPCORE structure and create a GDI logical
  196. // palette from the color table which follows it, for 2, 16 and 256 color
  197. // bitmaps. Fail for all others, including 24-bit DIB's
  198. //
  199. // It differs from the windows DIB routine in two respects:
  200. //
  201. //   1) The PM 1.x DIB must have complete color tables, since there is no
  202. //      ClrUsed field in the header
  203. //
  204. //   2) The size of the color table entries is 3 bytes, not 4 bytes.
  205. //
  206. void
  207. TPalette::Create(const BITMAPCOREINFO far* coreInfo, uint flags)
  208. {
  209.   const RGBTRIPLE far* rgb = coreInfo->bmciColors;
  210.  
  211.   uint16 nColors = (uint16)NColors(coreInfo->bmciHeader.bcBitCount);
  212.   if (nColors) {
  213.     LOGPALETTE* logPal = (LOGPALETTE*)
  214.        new uint8[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
  215.  
  216.     logPal->palVersion  = 0x300; // Windows 3.0 version
  217.     logPal->palNumEntries = nColors;
  218.     for (short n = 0; n < nColors; n++) {
  219.       logPal->palPalEntry[n].peRed   = rgb[n].rgbtRed;
  220.       logPal->palPalEntry[n].peGreen = rgb[n].rgbtGreen;
  221.       logPal->palPalEntry[n].peBlue  = rgb[n].rgbtBlue;
  222.       logPal->palPalEntry[n].peFlags = (uint8)flags;
  223.     }
  224.     Handle = ::CreatePalette(logPal);
  225.     delete[] logPal;
  226.   }
  227.   else
  228.     Handle = 0;
  229.  
  230.   WARNX(OwlGDI, !Handle, 0, "Cannot create palette from coreinfo @" <<
  231.         hex << uint32(LPVOID(coreInfo)));
  232.   CheckValid();
  233.   RefAdd(Handle, Palette);
  234. }
  235. #endif
  236.